package test;

import java.util.*;
public class Szys2 {
	 private static int intercePosition = 0; // 记录单个运算数据的长度
	 private static int[] intercePositionIndex = null; // 记录“（”的下标
	 private static int[] intercePositionEnd = null; // 记录“）”的下标

	 public static void main(String[] args) {
		 
	  //Scanner input = new Scanner(System.in);
	  //do {
	   //System.out.println("请输入你要计算的字符串(注意：只能输入数字和加，减，乘除符号;输入完毕后,请直接回车):");
		 Arithmetic A=new Arithmetic(true);
	        
		 String numberString = A.toString();
	   // 判断输入的运算字符串是否符合规定
	   //if (ispassString(numberString) == false) {
	    //System.out.println("您输入的计算字符串有误,请正确输入!");
	   //} else {
	    // 计算结果返回
	    System.out.println(interceResult(numberString));
	   //}
	 // } while (true);
	 }

	 // 判断是否有带括号的运算字符串存在
	 private static String interceResult(String str) {
	  String result = str;
	  char[] numberString = str.toCharArray(); // 1+2+(1*2+1-1*2+5)+2+(1+5+9+10-11)+1*5/2+3
	  // 1+8-9+(1*8/2-5+(1+2+8))+4/5*8/3*2
	  int IndexStart = 0; // 记录“（”的实际数量
	  int EndStart = 0; // 记录“）”的实际数量
	  for (int i = 0; i < numberString.length; i++) {
	   if ('(' == numberString[i]) {
	    // 记录最后一个正括号的位置
	    IndexStart = i;
	   }
	   if (')' == numberString[i]) {
	    // 记录反括号的最初始下标的位置
	    EndStart = i;

	    // 截取最里面一个括号里的运算字符串
	    result = result.substring(IndexStart + 1, EndStart);

	    // 截取括号的运算字符串进行运算,生成新的运算字符串
	    result = str.substring(0, IndexStart)
	      + interceptOperation(result, '*', '/')
	      + str.substring(EndStart + 1, str.length());

	    // 回调执行，其它小括号的运算字符串
	    return interceResult(result);
	   }
	   if (i == numberString.length - 1)
	    if (EndStart == 0)
	     break;
	  }
	  // 不存在括号了，再进行混合运算
	  result = interceptOperation(str, '*', '/');
	  return result;
	 }

	 // 不带括号的四则运算
	 private static String interceptOperation(String operationNumber, char a,
	   char b) {
	  String mess = operationNumber;
	  char[] stringOperation = mess.toCharArray();

	  // 循环遍历运算字符串，并做相应的运算
	  for (int i = 0; i < stringOperation.length; i++) {

	   // 判断运算符所在的索引
	   if (stringOperation[i] == a || stringOperation[i] == b) {
	    if (i != 0) {
	     // 运算符前的第一个数
	     double num1 = interceptNumIndex(mess.substring(0, i));

	     // 记录第一个数据的长度
	     int frontPosition = intercePosition;

	     // 运算符前的第二个数
	     double num2 = interceptNumEnd(mess.substring(i + 1,
	       stringOperation.length));

	     // 记录第二个数据的长度
	     int backPosition = intercePosition;

	     // 算完乘除，将结果替换到原来运算的位置，得到新的运算字符串
	     String IndexMess = mess.substring(0, i - frontPosition + 1);
	     String IndexResult = "";

	     // 判断是否运算到最后的结果了
	     if (IndexMess.indexOf('+') == -1
	       && IndexMess.indexOf('*') == -1
	       && IndexMess.indexOf('/') == -1
	       && IndexMess.lastIndexOf('-') == -1)
	      IndexMess = "";
	     if (IndexMess != "")
	      IndexResult = IndexMess.lastIndexOf('-') == IndexMess
	        .length() - 1 ? IndexMess.substring(0, i
	        - frontPosition) : IndexMess;

	     // 组装新的运算字符串
	     mess = IndexResult// mess.substring(0,i-frontPosition+1)
	       + reslutString("" + stringOperation[i], num1, num2)
	       + mess.substring(i + backPosition + 1);
	     // 0.111/1212/2/2/2/2/2/2/2
	     if (mess.lastIndexOf('-') == 0 && mess.indexOf('+') == -1
	       && mess.indexOf('*') == -1
	       && mess.indexOf('/') == -1) {
	      break;
	     }
	     // 回调，继续运算
	     return interceptOperation(mess, a, b);// 1+7-5+89/3+4-6*8/2+4-6
	    } else
	     continue;
	   }
	   if (i == stringOperation.length - 1) {
	    // 递归出口，判断是否还有运算字符串在
	    if (mess.indexOf('+') != -1 || mess.indexOf('-') != -1)
	     return interceptOperation(mess, '+', '-');
	    break;
	   }
	  }
	  return mess;
	 }

	 // 截取第二个数
	 private static double interceptNumEnd(String str) {
	  double a = 0;
	  int InrerceIndex = 0;
	  char[] stringOperation = str.toCharArray();
	  boolean ispas = false; // 记录是否为负数
	  for (int i = 0; i < stringOperation.length; i++) {
	   switch (stringOperation[i]) {
	   case '*':
	   case '/':
	   case '+':
	   case '-':
	    InrerceIndex = i;
	    if (i != 0) // 判断该数是否为负数
	     ispas = true;
	    break;
	   default:
	    break;
	   }
	   if (ispas)
	    break;
	  }
	  // 判断此数据是否在运算字符串的最后一位
	  if (InrerceIndex == 0) {
	   a = Double.parseDouble(str);
	   intercePosition = str.length();
	   if (ispas)
	    intercePosition++;

	  } else {
	   a = Double.parseDouble(str.substring(0, InrerceIndex));
	   // 记录数据的真实长度
	   intercePosition = str.substring(0, InrerceIndex).length();
	  }
	  return a;
	 }

	 // 截取第一个数
	 private static double interceptNumIndex(String str) {
	  double a = 0; // 记录数据
	  int InrerceIndex = 0; // 记录运算符的位置
	  boolean temp = false; // 记录数据前运算符的状态
	  char[] stringOperation = str.toCharArray();
	  for (int i = stringOperation.length - 1; i >= 0; i--) {
	   switch (stringOperation[i]) {
	   case '*':
	   case '/':

	   case '+':
	   case '-':
	    InrerceIndex = i;
	    temp = true;
	    break;
	   default:
	    break;
	   }
	   if (temp)
	    break;
	  }
	  // 判断此数据是否在运算字符串的第一位
	  if (InrerceIndex == 0) {
	   a = Double.parseDouble(str);
	   intercePosition = str.length();
	   // if(temp)
	   // intercePosition++;
	  } else {
	   a = Double.parseDouble(str.substring(InrerceIndex, str.length()));
	   // 记录数据的真实长度
	   intercePosition = str.substring(InrerceIndex, str.length())
	     .length();
	  }
	  return a;
	 }

	 // 计算结果
	 private static double reslutString(String operation, double num1,
	   double num2) {
	  double sumResult = 0;
	  if (operation.equals("*"))
	   sumResult = num1 * num2;
	  if (operation.equals("-"))
	   sumResult = num1 - num2;
	  if (operation.equals("/"))
	   sumResult = num1 / num2;
	  if (operation.equals("+"))
	   sumResult = num1 + num2;
	  return sumResult;
	 }

	 // 判断是否正确输入运算方式
	 private static boolean ispassString(String messString) {
	  boolean ispass = false;
	  boolean operationIspass = true; // 记录被除数的状态
	  int ai = 0; // 记录是否有运算符号的存在
	  char[] IsString = messString.toCharArray();
	  int num1 = 0;
	  int num2 = 0;
	  for (int i = 0; i < IsString.length; i++) {
	   // 记录有几对小括号的存在
	   if ('(' == IsString[i])
	    num1++;
	   if (')' == IsString[i])
	    num2++;

	   // 判断除数是否为零
	   if ('/' == IsString[i] && IsString[i + 1] == '0')
	    operationIspass = false;

	   // 判断是否输入了运算符合
	   if (IsString[i] == '+' || IsString[i] == '-' || IsString[i] == '*'
	     || IsString[i] == '/')
	    ai++;

	   if (i == IsString.length - 1)
	    if (ai == 0)
	     num2++;
	  }
	  if (operationIspass)
	   if (num1 == num2)
	    ispass = true;
	  return ispass;
	 }
	}
